home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / lame.h < prev    next >
C/C++ Source or Header  |  2000-01-01  |  14KB  |  386 lines
  1. /*
  2.  *    Interface to MP3 LAME encoding engine
  3.  *
  4.  *    Copyright (c) 1999 Mark Taylor
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2, or (at your option)
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; see the file COPYING.  If not, write to
  18.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20. #ifndef LAME_H_INCLUDE
  21. #define LAME_H_INCLUDE
  22. #include <stdio.h>
  23.  
  24. /* maximum size of mp3buffer needed if you encode at most 1152 samples for
  25.    each call to lame_encode_buffer.  see lame_encode_buffer() below  */
  26. #define LAME_MAXMP3BUFFER 16384
  27.  
  28.  
  29. typedef enum sound_file_format_e {
  30.   sf_unknown, sf_wave, sf_aiff, sf_mp3, sf_raw, sf_ogg 
  31. } sound_file_format;
  32.  
  33.  
  34. typedef enum vbr_mode_e {
  35.   vbr_off=0,
  36.   vbr_mt=1,
  37.   vbr_rh=2,
  38.   vbr_abr=3,
  39.   vbr_default=vbr_rh  /* change this to change the default VBR mode of LAME */ 
  40. } vbr_mode;
  41.  
  42.  
  43. typedef struct
  44. {
  45.     int valid;
  46.     char title[31];
  47.     char artist[31];
  48.     char album[31];
  49.     char year[5];
  50.     char comment[31];
  51.     char tagtext[128];
  52.     char genre[1];
  53.     unsigned char track;
  54.  
  55. }   ID3TAGDATA;
  56.  
  57.  
  58.  
  59.  
  60. /***********************************************************************
  61. *
  62. *  Control Parameters set by User
  63. *
  64. *  substantiated by calling program
  65. *
  66. *  Initilized and default values set by lame_init(&gf)
  67. *
  68. *
  69. ***********************************************************************/
  70. typedef struct  {
  71.   /* input file description */
  72.   unsigned long num_samples;  /* number of samples. default=2^32-1    */
  73.   int num_channels;           /* input number of channels. default=2  */
  74.   int in_samplerate;          /* input_samp_rate. default=44.1kHz     */
  75.   int out_samplerate;         /* output_samp_rate. (usually determined automatically)   */ 
  76.  
  77.   /* general control params */
  78.   int gtkflag;                /* run frame analyzer?       */
  79.   int bWriteVbrTag;           /* add Xing VBR tag?         */
  80.   int decode_only;            /* use lame/mpglib to convert mp3 to wav */
  81.   int ogg;                    /* encode to Vorbis .ogg file */
  82.  
  83.   int quality;                /* quality setting 0=best,  9=worst  */
  84.   int silent;                 /* disable some status output */
  85.   int brhist_disp;            /* enable VBR bitrate histogram display */
  86.   int mode;                       /* 0,1,2,3 stereo,jstereo,dual channel,mono */
  87.   int mode_fixed;                 /* use specified the mode, do not use lame's opinion of the best mode */
  88.   int force_ms;                   /* force M/S mode.  requires mode=1 */
  89.   int brate;                      /* bitrate */
  90.   float compression_ratio;          /* user specified compression ratio, instead of brate */
  91.   int free_format;                /* use free format? */
  92.  
  93.   /* frame params */
  94.   int copyright;                  /* mark as copyright. default=0 */
  95.   int original;                   /* mark as original. default=1 */
  96.   int error_protection;           /* use 2 bytes per frame for a CRC checksum. default=0*/
  97.   int padding_type;               /* 0=no padding, 1=always pad, 2=adjust padding */
  98.   int extension;                  /* the MP3 'private extension' bit.  meaningless */
  99.   int strict_ISO;                 /* enforce ISO spec as much as possible */
  100.  
  101.   /* quantization/noise shaping */
  102.   int disable_reservoir;          /* use bit reservoir? */
  103.   int experimentalX;            
  104.   int experimentalY;
  105.   int experimentalZ;
  106.  
  107.   /* VBR control */
  108.   vbr_mode VBR;
  109.   int VBR_q;
  110.   int VBR_mean_bitrate_kbps;
  111.   int VBR_min_bitrate_kbps;
  112.   int VBR_max_bitrate_kbps;
  113.   int VBR_hard_min;             /* strictly enforce VBR_min_bitrate*/
  114.                                 /* normaly, it will be violated for analog silence */
  115.  
  116.  
  117.   /* resampling and filtering */
  118.   int lowpassfreq;                /* freq in Hz. 0=lame choses. -1=no filter */
  119.   int highpassfreq;               /* freq in Hz. 0=lame choses. -1=no filter */
  120.   int lowpasswidth;               /* freq width of filter, in Hz (default=15%)*/
  121.   int highpasswidth;              /* freq width of filter, in Hz (default=15%)*/
  122.  
  123.  
  124.   /* I/O - not used if calling program does the i/o */
  125.   sound_file_format input_format;   
  126.   FILE * musicin;             /* file pointer to input file */
  127.   int swapbytes;              /* force byte swapping   default=0*/
  128. #define         MAX_NAME_SIZE           1000
  129.   char inPath[MAX_NAME_SIZE];
  130.   /* Note: outPath must be set if you want Xing VBR or id3 tags written */
  131.   char outPath[MAX_NAME_SIZE];
  132.  
  133.  
  134.  
  135.   /* optional id3 tags  */
  136.   int id3tag_used;
  137.   ID3TAGDATA id3tag;
  138.  
  139.  
  140.   /* psycho acoustics and other aguments which you should not change 
  141.    * unless you know what you are doing  */
  142.   int ATHonly;                    /* only use ATH */
  143.   int ATHshort;                   /* only use ATH for short blocks */
  144.   int noATH;                      /* disable ATH */
  145.   float cwlimit;                  /* predictability limit */
  146.   int allow_diff_short;       /* allow blocktypes to differ between channels ? */
  147.   int no_short_blocks;        /* disable short blocks       */
  148.   int emphasis;                   /* obsolete */
  149.  
  150.  
  151.  
  152.  
  153.   /************************************************************************/
  154.   /* internal variables, do not set... */
  155.   /************************************************************************/
  156.   int version;                /* 0=MPEG2  1=MPEG1 */
  157.   long int frameNum;              /* frame counter */
  158.   long totalframes;               /* frames: 0..totalframes-1 (estimate)*/
  159.   int encoder_delay;
  160.   int framesize;                  
  161.  
  162.  
  163.   /* VBR tags */
  164.   int nZeroStreamSize;
  165.   int TotalFrameSize;
  166.   int* pVbrFrames;
  167.   int nVbrNumFrames;
  168.   int nVbrFrameBufferSize;
  169.  
  170.  
  171.   /************************************************************************/
  172.   /* more internal variables, which will not exist after lame_encode_finish() */
  173.   /************************************************************************/
  174.   void *internal_flags;
  175.  
  176. } lame_global_flags;
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183. /*
  184.  
  185. The LAME API
  186.  
  187.  */
  188.  
  189.  
  190. /* REQUIRED: initialize the encoder.  sets default for all encoder paramters,
  191.  * returns -1 if some malloc()'s failed
  192.  * otherwise returns 0
  193.  * 
  194.  */
  195. int lame_init(lame_global_flags *);
  196.  
  197.  
  198.  
  199.  
  200. /*********************************************************************
  201.  * command line argument parsing & option setting.  Only supported
  202.  * if libmp3lame compiled with LAMEPARSE defined 
  203.  *********************************************************************/
  204. /* OPTIONAL: call this to print an error with a brief command line usage guide and quit 
  205.  * only supported if libmp3lame compiled with LAMEPARSE defined.  
  206.  */
  207. void lame_usage(lame_global_flags *, char *);
  208.  
  209. /* OPTIONAL: call this to print a command line interface usage guide and quit   */
  210. void lame_help(lame_global_flags *, char *);
  211.  
  212. /* OPTIONAL: get the version number, in a string. of the form:  "3.63 (beta)" or 
  213.    just "3.63".  Max allows length is 20 characters  */
  214. void lame_version(lame_global_flags *, char *);
  215.  
  216.  
  217. /* OPTIONAL: set internal options via command line argument parsing 
  218.  * You can skip this call if you like the default values, or if
  219.  * set the encoder parameters your self 
  220.  */
  221. void lame_parse_args(lame_global_flags *, int argc, char **argv);
  222.  
  223.  
  224.  
  225.  
  226.  
  227. /* REQUIRED:  sets more internal configuration based on data provided
  228.  * above.  returns -1 if something failed.
  229.  */
  230. int lame_init_params(lame_global_flags *);
  231.  
  232.  
  233. /* OPTONAL:  print internal lame configuration on stderr*/
  234. void lame_print_config(lame_global_flags *);
  235.  
  236.  
  237.  
  238.  
  239. /* input pcm data, output (maybe) mp3 frames.
  240.  * This routine handles all buffering, resampling and filtering for you.
  241.  * 
  242.  * leftpcm[]       array of 16bit pcm data, left channel
  243.  * rightpcm[]      array of 16bit pcm data, right channel
  244.  * num_samples     number of samples in leftpcm[] and rightpcm[] (if stereo)
  245.  * mp3buffer       pointer to buffer where mp3 output is written
  246.  * mp3buffer_size  size of mp3buffer, in bytes
  247.  * return code     number of bytes output in mp3buffer.  can be 0 
  248.  *                 -1:  mp3buffer was too small
  249.  *                 -2:  malloc() problem
  250.  *                 -3:  lame_init_params() not called
  251.  *                 -4:  psycho acoustic problems 
  252.  *                 -5:  ogg cleanup encoding error
  253.  *                 -6:  ogg frame encoding error
  254.  *
  255.  * The required mp3buffer_size can be computed from num_samples, 
  256.  * samplerate and encoding rate, but here is a worst case estimate:
  257.  *
  258.  * mp3buffer_size in bytes = 1.25*num_samples + 7200
  259.  *
  260.  * I think a tighter bound could be:  (mt, March 2000)
  261.  * MPEG1:
  262.  *    num_samples*(bitrate/8)/samplerate + 4*1152*(bitrate/8)/samplerate + 512
  263.  * MPEG2:
  264.  *    num_samples*(bitrate/8)/samplerate + 4*576*(bitrate/8)/samplerate + 256
  265.  *
  266.  * but test first if you use that!
  267.  *
  268.  * set mp3buffer_size = 0 and LAME will not check if mp3buffer_size is
  269.  * large enough.
  270.  *
  271.  * NOTE: if gfp->num_channels=2, but gfp->mode = 3 (mono), the L & R channels
  272.  * will be averaged into the L channel before encoding only the L channel
  273.  * This will overwrite the data in leftpcm[] and rightpcm[].
  274.  * 
  275. */
  276. int lame_encode_buffer(lame_global_flags *,short int leftpcm[], short int rightpcm[],int num_samples,
  277. char *mp3buffer,int  mp3buffer_size);
  278.  
  279. /* as above, but input has L & R channel data interleaved.  Note: 
  280.  * num_samples = number of samples in the L (or R)
  281.  * channel, not the total number of samples in pcm[]  
  282.  */
  283. int lame_encode_buffer_interleaved(lame_global_flags *,short int pcm[], 
  284. int num_samples, char *mp3buffer,int  mp3buffer_size);
  285.  
  286.  
  287.  
  288. /* input 1 pcm frame, output (maybe) 1 mp3 frame.  
  289.  * return code = number of bytes output in mp3buffer.  can be 0 
  290.  * NOTE: this interface is outdated, please use lame_encode_buffer() instead 
  291.  * declair mp3buffer with:  char mp3buffer[LAME_MAXMP3BUFFER] 
  292.  * if return code = -1:  mp3buffer was too small 
  293.  */
  294. int lame_encode(lame_global_flags *,short int Buffer[2][1152],char *mp3buffer,int mp3buffer_size);
  295.  
  296.  
  297.  
  298. /* REQUIRED:  lame_encode_finish will flush the buffers and may return a 
  299.  * final few mp3 frames.  mp3buffer should be at least 7200 bytes.
  300.  *
  301.  * return code = number of bytes output to mp3buffer.  can be 0
  302.  */
  303. int lame_encode_finish(lame_global_flags *,char *mp3buffer, int size);
  304.  
  305.  
  306. /* OPTIONAL:  lame_mp3_tags will append id3 and Xing VBR tags to
  307. the mp3 file with name given by gf->outPath.  These calls open the file,
  308. write tags, and close the file, so make sure the the encoding is finished
  309. before calling these routines.  
  310. Note: if VBR and id3 tags are turned off by the user, or turned off
  311. by LAME because the output is not a regular file, this call does nothing
  312. */
  313. void lame_mp3_tags(lame_global_flags *);
  314.  
  315.  
  316.  
  317.  
  318. /*********************************************************************
  319.  * lame file i/o.  Only supported
  320.  * if libmp3lame compiled with LAMESNDFILE or LIBSNDFILE
  321.  *********************************************************************/
  322. /* OPTIONAL: open the input file, and parse headers if possible 
  323.  * you can skip this call if you will do your own PCM input 
  324.  */
  325. void lame_init_infile(lame_global_flags *);
  326.  
  327. /* OPTIONAL:  read one frame of PCM data from audio input file opened by 
  328.  * lame_init_infile.  Input file can be wav, aiff, raw pcm, anything
  329.  * supported by libsndfile, or an mp3 file
  330.  */
  331. int lame_readframe(lame_global_flags *,short int Buffer[2][1152]);
  332.  
  333. /* OPTIONAL: close the sound input file if lame_init_infile() was used */
  334. void lame_close_infile(lame_global_flags *);
  335.  
  336.  
  337.  
  338.  
  339.  
  340. /*********************************************************************
  341.  * a simple interface to mpglib, part of mpg123, is also included if
  342.  * libmp3lame is compiled with HAVEMPGLIB
  343.  * input 1 mp3 frame, output (maybe) pcm data.  
  344.  * lame_decode return code:  -1: error.  0: need more data.  n>0: size of pcm output
  345.  *********************************************************************/
  346. typedef struct {
  347.   int stereo;      /* number of channels */
  348.   int samplerate;  /* sample rate */
  349.   int bitrate;     /* bitrate */
  350.   unsigned long nsamp;    /* number of samples in mp3 file, estimated */
  351. } mp3data_struct;
  352.  
  353.  
  354. int lame_decode_init(void);
  355. int lame_decode(char *mp3buf,int len,short pcm_l[],short pcm_r[]);
  356.  
  357. /* same as lame_decode, but returns at most one frame */
  358. int lame_decode1(char *mp3buf,int len,short pcm_l[],short pcm_r[]);
  359.  
  360.  
  361. /* read mp3 file until mpglib returns one frame of PCM data */
  362. #ifdef AMIGA_MPEGA
  363. int lame_decode_initfile(const char *fullname,mp3data_struct *mp3data);
  364. int lame_decode_fromfile(FILE *fd,short int pcm_l[], short int pcm_r[],mp3data_struct *mp3data);
  365. #else
  366. int lame_decode_initfile(FILE *fd,mp3data_struct *mp3data);
  367. int lame_decode_fromfile(FILE *fd,short int pcm_l[],short int pcm_r[],mp3data_struct *mp3data);
  368. #endif
  369.  
  370. /* and for Vorbis: */
  371. int lame_decode_ogg_initfile(FILE *fd,mp3data_struct *mp3data);
  372. int lame_decode_ogg_fromfile(FILE *fd,short int pcm_l[],short int pcm_r[],mp3data_struct *mp3data);
  373.  
  374. /* the simple lame decoder (interface to above routines) */
  375. /* After calling lame_init(), lame_init_params() and
  376.  * lame_init_infile(), call this routine to read the input MP3 file 
  377.  * and output .wav data to the specified file pointer*/
  378. /* lame_decoder will ignore the first 528 samples, since these samples
  379.  * represent the mpglib delay (and are all 0).  skip = number of additional
  380.  * samples to skip, to (for example) compensate for the encoder delay,
  381.  * only used when decoding mp3 */
  382. int lame_decoder(lame_global_flags *gfp,FILE *outf,int skip);
  383.  
  384.  
  385. #endif
  386.